import pygame
from pygame.locals import*
from random import shuffle
from MasterMind import*

def is_over(component):
    
    ''' verifica se o mouse pressionado esta sobre este componente '''
    
    point_x, point_y = pygame.mouse.get_pos()
    x, y = component.cord
    w, h = component.get_size()
    
    in_x = point_x >= x and point_x <= x + w
    in_y = point_y >= y and point_y <= y + h
        
    return in_x and in_y

class Button:
    
    def __init__(self, image_up, image_over, cord):
        
        ''' instancia a imagem - butao, passados o nome do arquivo(imagem)
        e sua posicao(uma tupla)'''
        
        self.cord = cord
        self.image_up = pygame.image.load(image_up).convert_alpha()
        self.image_over = pygame.image.load(image_over).convert_alpha()
        
    def render(self, surface):
        
        ''' prende a imagem no fundo de tela '''
        
        if is_over(self):        
            surface.blit(self.image_over, self.cord)
        else:
            surface.blit(self.image_up, self.cord)
    
    def get_size(self):
        
        '''retorna a imagem que aparecera sobre o butao, quando o mouse colidir com o botao'''
        
        return self.image_up.get_size()
    
class GraphicPine(Pine):
    
    '''herda os metodos da classe Pine'''

    def __init__(self, color, image, cord = (0,0)):
        
        '''metodo construtor da classe GraphicPine'''
        
        Pine.__init__(self, color)
        self.image = pygame.image.load(image).convert_alpha()
        self.cord = cord

    def render(self, surface):
        
        '''prende a imagem no background da tela'''
        
        surface.blit(self.image, self.cord)

    def get_size(self):
        
        '''retorna a o tamanho da imagem: altura x largura'''
        
        return self.image.get_size()
    
    def copy(self):
        
        '''instancia uma copia de um pino'''
        
        return GraphicPine(self.color, 'imagens/pine_%s.png' % self.color, self.cord)

class GraphicBlock(Block):
    
        def __init__(self, size, image, cord=(0,0)):
            
            '''metodo construtor da classe GraphicBlock'''
                       
            Block.__init__(self, size)
            self.image = pygame.image.load(image).convert_alpha()
            self.cord = cord

        def add_pine(self, pine, position):
            
            '''adiciona pino em determinada posicao;
            retorna False - pino nao adicionado 
            retorna True - pino adicionado'''
   
            if not position > len(self) -1 and not position < 0 and Block.add_pine(self, pine, position):
                x, y = self.cord
                pine.cord = (10 + x + (pine.image.get_size()[0] + 10) * position, y)
                return True
            return False
            
                

        def result_block(self, block):
            
            '''retorna o bloco de acertos
            black adicionado ao bloco - acerto de posicao
            white adicionado ao bloco - acerto apenas da cor'''
            
            result = Block.result_block(self, block)
            hit = GraphicBlock(len(result), 'imagens/block_result.png')
            hit.cord = (self.cord[0] + 320, self.cord[1])
            for i in xrange(len(result)):
                if result.get_pine(i) != None:
                    hit.add_pine(GraphicPine(result.get_pine(i).get_color(), 'imagens/pine_%s.png'%result.get_pine(i).get_color()), i)    
                    hit.get_pine(i).cord = (hit.cord[0] + 5 + (hit.get_pine(i).get_size()[0] + 5) * i, hit.cord[1])
            return hit      
        
        def render(self, space, image,  surface):
            
            '''prende todos os pinos do bloco e bloco no fundo de tela'''
            
            surface.blit(self.image, self.cord)
            for i in xrange(len(self)):
                if self.get_pine(i) == None:
                    x, y =  self.cord
                    image_none = pygame.image.load(image).convert_alpha()
                    surface.blit(image_none, (space + x + (image_none.get_size()[0] + space) * i, y))
                else:
                    self.get_pine(i).render(surface)
        
        def copy(self, image):
            
            '''retorna uma copia do bloco'''
            
            new_block = GraphicBlock(len(self), image, self.cord)
            for i in xrange(len(new_block)):
                if self.get_pine(i) != None:
                    new_block.pines[i] = self.pines[i].copy()
            return new_block                                                               
